﻿using System;
using System.Collections.Generic;

namespace 面向对象_泛型3
{
    class Program
    {
        static void Main(string[] args)
        {
            //冒泡
            List<int> a = new List<int> { 12, 13, 14, 2, 5, 6, 7, 8, 9, 1};
            Console.WriteLine("Before : " + string.Join(" - ", a));//Before 之前 
            for (int i = 0; i < a.Count-1; i++)
            {
                for (int j = 0; j < a.Count-1-i; j++)
                {
                    int b = a[j];//使用b和c来接受当前循环的值b接收循环次数，c来接受数组集合中的值
                    int c = a[j + 1];
                    if (b>c)//如果b大于c如果前面的值大于后面的值那么就将他们进行交换
                    {
                        c += b;//前面的值加上后面的值b现在是两个数的总值
                        b = c - b;//后面的值就是总值减去后面的值得出他原本的值
                                  // lhs+lhs = rhs 👉2lhs=rhs 👉lhs = rhs/2
                                  // lhs = rhs / 2; //不成立
                        c -= b;//总值在减去c原本的值，得出b原本的值，进行调换
                    }
                    a[j] = b;
                    a[j + 1] = c;
                }
            }
            Console.WriteLine("After : " + string.Join(" - ", a));
            // Swap If Greater : 如果更大就交换
            // IComparable ： I ，interface ，Comparable 可对比的
            // temp :临时的 （变量）
            static void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : System.IComparable<T>
            {
                T temp;
                if (lhs.CompareTo(rhs) > 0)
                {
                    temp = lhs;
                    lhs = rhs;
                    rhs = temp;
                }
                
            }
            

        }
        // 泛型方法可以重载,只要类型参数数量不一即可
        void DoWork() { }
        void DoWork<T>() { }
        void DoWork<T, U>() { }
        interface ITest<T>
        {
        }
        interface ITest<T, V>
        {
        }
        interface ITest<T, U, V>
        {
        }

        //适用于类类型的接口规制同样适用于接口
        // 处理的元素一致，步伐一致, 泛型参数个数一致
        // interface Itesta<S,V> : ITest<S>  //ok
        //interface Itesta<S> : ITest<S,V>  // NG, 接口少声明了 V 
        interface Itesta<S, V> : ITest<S, V, V> //后面的接口需要三个参数，用前面出现的参数填充
        {
        }

        // 泛型接口的约束继承
        interface ITestbs<T> where T : struct
        {
        }

        // 一旦被继承的接口有约束，那么继承接口就必须（显式）补全这个约束
        interface ITestbbs<T> : ITestbs<T> where T : struct
        {
        }
        interface ITestbbsi<T> : ITestbs<T> where T : struct
        {
        }

        // 约束必须是  接口，非密封类，类型参数
        // 示例中， Book 结构，int32 不是有效的约束
        // 泛型中，想要约束类型为值类型，就只有一个选择：struct 
        //  这个规则不在乎你是 interface 还是 class
        //struct Book { }
        //interface ITestb<U> where U :Book//不可约束
        //{
        //}
        //interface ITestint<U> where U : Int32
        //{ }
        //class Testint<U> where U : Int32
        //{ }

        interface ITestbp<T> where T : Program//可以用类型名来约束
        {
        }

        interface ITestbbp<T> : ITestbp<T> where T : Program//继承 ITestbp<T>
        {

        }

        interface ITestbc<T> where T : class//也可以用class来进行约束
        {
        }

        interface ITestbbcp<T> : ITestbc<T> where T : Program//约束为class继承类必须相同，而program类名也可以，系统默认也是引用类型
        {
        }

        interface ITestbbc<T> : ITestbc<T> where T : class//约束为class
        {
        }

    }
}
